home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Utilities / MultiNotify / MultiNotify.mod < prev    next >
Encoding:
Text File  |  1997-08-08  |  63.3 KB  |  2,020 lines

  1.  
  2. ;
  3. ;  Hey men !  This isen't a Protacker music module but an Oberon-II source file !!!
  4. ;
  5.  
  6. .key CMD/A
  7. .bra {
  8. .ket }
  9.  
  10. If {CMD} EQ "Lnk"
  11.     IF `RequestChoice TITLE "Link" BODY "Run ?" GADGETS "Y|N"` EQ "1"
  12.         Skip Rn
  13.     EndIf
  14.     Skip Lnk
  15. EndIf
  16.  
  17. FailAt 11
  18. Stack 16384
  19. Oberon-A:OC Main.mod ;NS
  20. If Warn
  21.     Skip Errs
  22. EndIf
  23.  
  24. Lab Lnk
  25. Blink WITH /Divers/MainAll.withs
  26. IF `RequestChoice TITLE "Linked" BODY "Run ?" GADGETS "Y|N"` EQ "0"
  27.     Quit
  28. EndIf
  29.  
  30. Lab Rn
  31. /Main
  32. Quit
  33.  
  34. Lab Errs
  35. Oberon-A:OEL Main
  36. Quit
  37.  
  38.  
  39.  
  40. (*
  41. :: >> Utiliser les fonctions dos asynchrones pour le stockage des préfs
  42. *)
  43.  
  44.  
  45.  
  46. <*STANDARD-*>
  47. <*MAIN+*>
  48.  
  49.  
  50. MODULE Main;
  51.  
  52.  
  53.  
  54.  
  55.  
  56. IMPORT  E := Exec,  dos := Dos,  L := Localize,  U := Utility,  str := Strings,
  57.         sys := SYSTEM,  T := Triton_nl,  com := Commodities,  s := Sets,  Util,  Icon,
  58.         <* IF TEST THEN *>  WBConsole,  <* END *>  Workbench,
  59.         int := Intuition,  asl := Asl_nl,  Kernel,  Errors;
  60.  
  61.  
  62.  
  63.  
  64.  
  65. CONST
  66.     noMemN      = 00;      noMemS      = "Not enough memory";
  67.     emptyN      = 01;      emptyS      = "<Empty>";
  68.     watchedN    = 02;      watchedS    = "Watched Files:";
  69.     lvHlpN      = 03;      lvHlpS      = "List of files to start notification on.";
  70.     pathN       = 04;      pathS       = "Path:";
  71.     pathHlpN    = 05;      pathHlpS    = "Path of the notified file.";
  72.     fileN       = 06;      fileS       = "File:";
  73.     fileHlpN    = 07;      fileHlpS    = "Enter here the file on which\nthe notification should be started.";
  74.     aslfHlpN    = 08;      aslfHlpS    = "Select the files easily with\nthe asl-filerequester.";
  75.     exesN       = 09;      exesS       = "Execute:";
  76.     exesHlpN    = 10;      exesHlpS    = "AmigaDOS command to execute\nwhen a file is modified.\nThe output is by default directed to NIL:\nYou can redirect it using a '>' character.";
  77.     aslcHlpN    = 11;      aslcHlpS    = "Select the commands easily\nwith the asl-filerequester.";
  78.     exeN        = 12;      exeS        = "Execute";
  79.     exeHlpN     = 13;      exeHlpS     = "Use this button to execute\nthe specifed command now !\nNote: MultiNotify won't wait\nthe end of the execution";
  80.     newN        = 14;      newS        = "New";
  81.     newHlpN     = 15;      newHlpS     = "Adds a new notification-file to the list";
  82.     delN        = 16;      delS        = "Delete";
  83.     delHlpN     = 17;      delHlpS     = "Suppress the selected item of the list.";
  84.     savN        = 18;      savS        = "Save";
  85.     savHlpN     = 19;      savHlpS     = "Save the current settings definitely.";
  86.     useN        = 20;      useS        = "Use";
  87.     useHlpN     = 21;      useHlpS     = "Save the current settings\ntemporarily (only to ENV:)\nThe modifications will\nbe lost after a reboot.";
  88.     hidN        = 22;      hidS        = "Hide";
  89.     hidHlpN     = 23;      hidHlpS     = "Hide the interface.  You can reopen this window\nusing the Commodities/Exchange program.\nNote: The modifications won't take effect now.";
  90.     canN        = 24;      canS        = "Cancel";
  91.     canHlpN     = 25;      canHlpS     = "Undoes all the current modifications.\nThe previous configuration is loaded again.";
  92.     okN         = 26;      okS         = "Ok";
  93.     prfCrptN    = 27;      prfCrptS    = "Prefs file is corrupted.";
  94.     cfgSErrN    = 28;      cfgSErrS    = "Can't save configuration file.";
  95.     exeErrN     = 29;      exeErrS     = "Can't execute specified command.";
  96.     SEnvarcErrN = 30;      SEnvarcErrS = "Unable to save  config to ENVARC:";
  97.     SEnvErrN    = 31;      SEnvErrS    = "Unable to save config to ENV:";
  98.     LEnvErrN    = 32;      LEnvErrS    = "Unable to load config file from ENV:";
  99.     intTrErrN   = 33;      intTrErrS   = "Internal Triton error";
  100.     noTrLibN    = 34;      noTrLibS    = "Can't open version 6 of triton.library.\nThis library must be installed in LIBS:\nor in the directory of the application.";
  101.     noTrIntN    = 35;      noTrIntS    = "Can't initialize Triton interface.";
  102.     noAslLibN   = 36;      noAslLibS   = "Can't open asl.library.";
  103.  
  104.     TTBubName =  "HELPBUBBLES";
  105.  
  106.     configLName = "ENV:MultiNotify.prefs";
  107.     configSName = "ENVARC:MultiNotify.prefs";
  108.     envarc = TRUE;    env = ~envarc;    (* pour sauvegarde des prefs *)
  109.  
  110.     appName  =  "MultiNotify";
  111.     winTitle = "MultiNotify 1.0  © BURNAND Patrick";
  112.     appTitle = "The AmigaDOS file Watcher";
  113.  
  114.     winID       = 1;    (* fenêtre de l'app *)
  115.     lvID        = 1;    (* gadget ListView *)
  116.     fileStrID   = 2;    (* string gadget fichier à surveiller *)
  117.     getffileID  = 3;    (* gadget GetFile du fichier à surveiller *)
  118.     exeStrID    = 4;    (* string gadget du fichier à exécuter *)
  119.     getfexeID   = 5;    (* gadget GetFile du fichier à exécuter *)
  120.     exebuttID   = 6;    (* button Execute *)
  121.     newbuttID   = 7;    (* button New *)
  122.     delbuttID   = 8;    (* button New *)
  123.     savebuttID  = 9;    (* button Save *)
  124.     usebuttID   = 10;   (* button Use *)
  125.     hidebuttID  = 11;   (* button Hide *)
  126.     cancbuttID  = 12;   (* button Cancel *)
  127.     pathStrID   = 13;   (* string gadget chemin du fichier à surveiller *)
  128.  
  129.     internalVer = 4;    (* Version du catalog et fichier préférences *)
  130.  
  131.  
  132.  
  133.  
  134.  
  135. TYPE
  136.     _path = ARRAY 258 OF CHAR;
  137.     _name = ARRAY 32 OF CHAR;
  138.     _cmd = ARRAY 258 OF CHAR;
  139.  
  140.     (* données à sauver sur disk *)
  141.     _FilePtr = POINTER TO _File;
  142.     _File = RECORD
  143.         path : _path;
  144.         name : _name;
  145.         cmd  : _cmd;
  146.     END;
  147.  
  148.     (* ne doit pas être sauvé dans les préfs *)
  149.     _notify = RECORD
  150.         n  : dos.NotifyRequest;  (*  *)
  151.         ok : BOOLEAN;            (* la demande de notification a fonctionné *)
  152.     END;
  153.  
  154.     (* élément de la liste chaînée *)
  155.     _FileNodePtr = POINTER TO _FileNode;
  156.     _FileNode = RECORD
  157.         node   : E.Node;
  158.         file   : _File;             (* sauvés sur disk *)
  159.         notify : _notify;
  160.     END;
  161.  
  162.     _projTags = ARRAY 122 OF U.TagItem;   (* >=122 *)
  163.  
  164.  
  165.  
  166.  
  167.  
  168. VAR
  169.     FileListHeader : E.MinList;         (* n'est pas un élément de la liste *)
  170.     locStrPtr : E.LSTRPTR;              (* stockage temp chaîne localisée *)
  171.     openNow  : BOOLEAN;                 (* indique s'il faut ouvrir l'interface immédiatement *)
  172.  
  173.     BrokerPortPtr : E.MsgPortPtr;       (* Interface Commoditites *)
  174.     BrokerPtr : com.CxObjPtr;           (*  *)
  175.     NewBroker : com.NewBroker;          (*  *)
  176.     BrokerWaitSig : SET;                (* Signal à attendre de Exchange *)
  177.  
  178.     NotifyMsgPortPtr : E.MsgPortPtr;    (* Port sur lequel on reçoit la notification *)
  179.     NotifyWaitSig : SET;
  180.     StartNotify : BOOLEAN;    (* Var temporaire pour la fonction NotifyAllNow *)
  181.  
  182.     projTagsPtr : POINTER TO _projTags; (* Init interface Triton *)
  183.     application : T.AppPtr;
  184.     mainProject : T.ProjectPtr;
  185.     actlvID     : E.ULONG;         (* Élément actuellement sélectionné dans le listview *)
  186.     guiOpened : BOOLEAN;           (* Indique si l'interface est ouverte (pour CloseGui()) *)
  187.  
  188.     TT : RECORD                 (* Tooltypes *)
  189.       Bubbles : BOOLEAN;        (* Bulles d'aides activées *)
  190.     END;
  191.  
  192.  
  193.  
  194. (* crée le tableaux de Tags pour Triton.  tags doit avoir une longueur suffisante *)
  195. <*$CopyArrays-*>
  196. PROCEDURE InitGuiTags (tags: ARRAY OF U.TagItem) ;
  197. VAR
  198.     tagNum : INTEGER;
  199. BEGIN
  200.     tagNum := 0;
  201.     tags[tagNum].tag  :=  T.wiID;
  202.     tags[tagNum].data :=  winID;
  203.     INC(tagNum);
  204.     tags[tagNum].tag  :=  T.wiTitle;
  205.     tags[tagNum].data :=  sys.ADR(winTitle);
  206.     INC(tagNum);
  207.     tags[tagNum].tag  :=  T.wiBackfill;
  208.     tags[tagNum].data :=  T.bfWindowBack;
  209.     INC(tagNum);
  210.     tags[tagNum].tag  :=  T.wiPosition;
  211.     tags[tagNum].data :=  T.wpCenterDisplay;
  212.     INC(tagNum);
  213.     tags[tagNum].tag  :=  T.wiQuickHelp;
  214.     tags[tagNum].data :=  0;
  215.     IF  TT.Bubbles  THEN  tags[tagNum].data :=  1  END;
  216.     INC(tagNum);
  217.  
  218.     tags[tagNum].tag  :=  T.grHoriz;
  219.     tags[tagNum].data :=  T.grPropShare + T.grAlign + T.grCenter;
  220.     INC(tagNum);
  221.  
  222.     tags[tagNum].tag  :=    T.grVert;
  223.     tags[tagNum].data :=    T.grPropShare + T.grAlign + T.grCenter;
  224.     INC(tagNum);
  225.  
  226.     tags[tagNum].tag  :=      T.grHoriz;
  227.     tags[tagNum].data :=      T.grPropShare + T.grAlign (*+ T.grCenter*);
  228.     INC(tagNum);
  229.     tags[tagNum].tag  :=        T.obSpace;
  230.     tags[tagNum].data :=        T.stNormal;
  231.     INC(tagNum);
  232.  
  233.     tags[tagNum].tag  :=        T.grVert;
  234.     tags[tagNum].data :=        T.grPropShare + T.grAlign (*+ T.grCenter*);
  235.     INC(tagNum);
  236.     tags[tagNum].tag  :=          T.obSpace;
  237.     tags[tagNum].data :=          T.stNormal;
  238.     INC(tagNum);
  239.     tags[tagNum].tag  :=          T.obFrameBox;
  240.     tags[tagNum].data :=          T.fbFraming;
  241.     INC(tagNum);
  242.     tags[tagNum].tag  :=          T.atText;
  243.     locStrPtr := L.CatStr(watchedN, watchedS);
  244.     tags[tagNum].data :=          locStrPtr;
  245.     INC(tagNum);
  246.  
  247.     tags[tagNum].tag  :=          T.grVert;
  248.     tags[tagNum].data :=          T.grPropShare + T.grAlign (*+ T.grCenter*);
  249.     INC(tagNum);
  250.     tags[tagNum].tag  :=            T.obSpace;
  251.     tags[tagNum].data :=            T.stSmall;
  252.     INC(tagNum);
  253.  
  254.     tags[tagNum].tag  :=            T.grHoriz;
  255.     tags[tagNum].data :=            T.grPropShare + T.grAlign + T.grCenter;
  256.     INC(tagNum);
  257.     tags[tagNum].tag  :=              T.obSpace;
  258.     tags[tagNum].data :=              T.stNormal;
  259.     INC(tagNum);
  260.     tags[tagNum].tag  :=              T.obListview;
  261.     tags[tagNum].data :=              sys.ADR(FileListHeader);
  262.     INC(tagNum);
  263.     tags[tagNum].tag  :=              T.atID;
  264.     tags[tagNum].data :=              lvID;
  265.     INC(tagNum);
  266.     tags[tagNum].tag  :=              T.atFlags;
  267.     tags[tagNum].data :=              T.lvShowSelected + (*T.lvFWFont +*) T.lvNoGap;
  268.     INC(tagNum);
  269.     tags[tagNum].tag  :=              T.atMinWidth;
  270.     tags[tagNum].data :=              10;
  271.     INC(tagNum);
  272.     tags[tagNum].tag  :=              T.doQuickHelpString;
  273.     locStrPtr := L.CatStr(lvHlpN, lvHlpS);
  274.     tags[tagNum].data :=              locStrPtr;
  275.     INC(tagNum);
  276.     tags[tagNum].tag  :=              T.atValue;
  277.     tags[tagNum].data :=              0;     (* devrait contenir le dernier item sélectionné *)
  278.     INC(tagNum);
  279.     tags[tagNum].tag  :=              T.obSpace;
  280.     tags[tagNum].data :=              T.stNormal;
  281.     INC(tagNum);
  282.     tags[tagNum].tag  :=            T.grEnd;
  283.     tags[tagNum].data :=            0;
  284.     INC(tagNum);
  285.  
  286.     tags[tagNum].tag  :=            T.obSpace;
  287.     tags[tagNum].data :=            T.stNormal;
  288.     INC(tagNum);
  289.  
  290.     tags[tagNum].tag  :=            T.grHoriz;
  291.     tags[tagNum].data :=            T.grPropShare + T.grAlign + T.grCenter;
  292.     INC(tagNum);
  293.     tags[tagNum].tag  :=              T.obSpace;
  294.     tags[tagNum].data :=              T.stNormal;
  295.     INC(tagNum);
  296.     tags[tagNum].tag  :=              T.obText;
  297.     tags[tagNum].data :=              0;
  298.     INC(tagNum);
  299.     tags[tagNum].tag  :=              T.atText;
  300.     locStrPtr := L.CatStr(pathN, pathS);
  301.     tags[tagNum].data :=              locStrPtr;
  302.     INC(tagNum);
  303.     tags[tagNum].tag  :=              T.atFlags;
  304.     tags[tagNum].data :=              0;
  305.     INC(tagNum);
  306.     tags[tagNum].tag  :=              T.obSpace;
  307.     tags[tagNum].data :=              T.stNormal;
  308.     INC(tagNum);
  309.     tags[tagNum].tag  :=              T.obString;
  310.     locStrPtr := L.CatStr(emptyN, emptyS);
  311.     tags[tagNum].data :=              locStrPtr;
  312.     INC(tagNum);
  313.     tags[tagNum].tag  :=              T.atValue;
  314.     tags[tagNum].data :=              SIZE(_path);
  315.     INC(tagNum);
  316.     tags[tagNum].tag  :=              T.atID;
  317.     tags[tagNum].data :=              pathStrID;
  318.     INC(tagNum);
  319.     tags[tagNum].tag  :=              T.doQuickHelpString;
  320.     locStrPtr := L.CatStr(pathHlpN, pathHlpS);
  321.     tags[tagNum].data :=              locStrPtr;
  322.     INC(tagNum);
  323.     tags[tagNum].tag  :=              T.obSpace;
  324.     tags[tagNum].data :=              T.stNormal;
  325.     INC(tagNum);
  326.     tags[tagNum].tag  :=            T.grEnd;
  327.     tags[tagNum].data :=            0;
  328.     INC(tagNum);
  329.  
  330.     tags[tagNum].tag  :=            T.obSpace;
  331.     tags[tagNum].data :=            T.stNormal;
  332.     INC(tagNum);
  333.  
  334.     tags[tagNum].tag  :=            T.grHoriz;
  335.     tags[tagNum].data :=            T.grPropShare + T.grAlign + T.grCenter;
  336.     INC(tagNum);
  337.     tags[tagNum].tag  :=              T.obSpace;
  338.     tags[tagNum].data :=              T.stNormal;
  339.     INC(tagNum);
  340.     tags[tagNum].tag  :=              T.obText;
  341.     tags[tagNum].data :=              0;
  342.     INC(tagNum);
  343.     tags[tagNum].tag  :=              T.atText;
  344.     locStrPtr := L.CatStr(fileN, fileS);
  345.     tags[tagNum].data :=              locStrPtr;
  346.     INC(tagNum);
  347.     tags[tagNum].tag  :=              T.atFlags;
  348.     tags[tagNum].data :=              0;
  349.     INC(tagNum);
  350.     tags[tagNum].tag  :=              T.obSpace;
  351.     tags[tagNum].data :=              T.stNormal;
  352.     INC(tagNum);
  353.     tags[tagNum].tag  :=              T.obString;
  354.     locStrPtr := L.CatStr(emptyN, emptyS);
  355.     tags[tagNum].data :=              locStrPtr;
  356.     INC(tagNum);
  357.     tags[tagNum].tag  :=              T.atValue;
  358.     tags[tagNum].data :=              SIZE(_name);
  359.     INC(tagNum);
  360.     tags[tagNum].tag  :=              T.atID;
  361.     tags[tagNum].data :=              fileStrID;
  362.     INC(tagNum);
  363.     tags[tagNum].tag  :=              T.doQuickHelpString;
  364.     locStrPtr := L.CatStr(fileHlpN, fileHlpS);
  365.     tags[tagNum].data :=              locStrPtr;
  366.     INC(tagNum);
  367.     tags[tagNum].tag  :=              T.obSpace;
  368.     tags[tagNum].data :=              T.stSmall;
  369.     INC(tagNum);
  370.     tags[tagNum].tag  :=              T.obButton;
  371.     tags[tagNum].data :=              T.btGetFile;
  372.     INC(tagNum);
  373.     tags[tagNum].tag  :=              T.atID;
  374.     tags[tagNum].data :=              getffileID;
  375.     INC(tagNum);
  376.     tags[tagNum].tag  :=              T.doQuickHelpString;
  377.     locStrPtr := L.CatStr(aslfHlpN, aslfHlpS);
  378.     tags[tagNum].data :=              locStrPtr;
  379.     INC(tagNum);
  380.     tags[tagNum].tag  :=              T.obSpace;
  381.     tags[tagNum].data :=              T.stNormal;
  382.     INC(tagNum);
  383.     tags[tagNum].tag  :=            T.grEnd;
  384.     tags[tagNum].data :=            0;
  385.     INC(tagNum);
  386.  
  387.     tags[tagNum].tag  :=            T.obSpace;
  388.     tags[tagNum].data :=            T.stNormal;
  389.     INC(tagNum);
  390.  
  391.     tags[tagNum].tag  :=            T.grHoriz;
  392.     tags[tagNum].data :=            T.grPropShare + T.grAlign + T.grCenter;
  393.     INC(tagNum);
  394.     tags[tagNum].tag  :=              T.obSpace;
  395.     tags[tagNum].data :=              T.stNormal;
  396.     INC(tagNum);
  397.     tags[tagNum].tag  :=              T.obText;
  398.     tags[tagNum].data :=              0;
  399.     INC(tagNum);
  400.     tags[tagNum].tag  :=              T.atText;
  401.     locStrPtr := L.CatStr(exesN, exesS);
  402.     tags[tagNum].data :=              locStrPtr;
  403.     INC(tagNum);
  404.     tags[tagNum].tag  :=              T.atFlags;
  405.     tags[tagNum].data :=              0;
  406.     INC(tagNum);
  407.     tags[tagNum].tag  :=              T.obSpace;
  408.     tags[tagNum].data :=              T.stNormal;
  409.     INC(tagNum);
  410.     tags[tagNum].tag  :=              T.obString;
  411.     locStrPtr := L.CatStr(emptyN, emptyS);
  412.     tags[tagNum].data :=              locStrPtr;
  413.     INC(tagNum);
  414.     tags[tagNum].tag  :=              T.atValue;
  415.     tags[tagNum].data :=              SIZE(_cmd);
  416.     INC(tagNum);
  417.     tags[tagNum].tag  :=              T.atID;
  418.     tags[tagNum].data :=              exeStrID;
  419.     INC(tagNum);
  420.     tags[tagNum].tag  :=              T.doQuickHelpString;
  421.     locStrPtr := L.CatStr(exesHlpN, exesHlpS);
  422.     tags[tagNum].data :=              locStrPtr;
  423.     INC(tagNum);
  424.     tags[tagNum].tag  :=              T.obSpace;
  425.     tags[tagNum].data :=              T.stSmall;
  426.     INC(tagNum);
  427.     tags[tagNum].tag  :=              T.obButton;
  428.     tags[tagNum].data :=              T.btGetFile;
  429.     INC(tagNum);
  430.     tags[tagNum].tag  :=              T.atID;
  431.     tags[tagNum].data :=              getfexeID;
  432.     INC(tagNum);
  433.     tags[tagNum].tag  :=              T.doQuickHelpString;
  434.     locStrPtr := L.CatStr(aslcHlpN, aslcHlpS);
  435.     tags[tagNum].data :=              locStrPtr;
  436.     INC(tagNum);
  437.     tags[tagNum].tag  :=              T.obSpace;
  438.     tags[tagNum].data :=              T.stNormal;
  439.     INC(tagNum);
  440.     tags[tagNum].tag  :=            T.grEnd;
  441.     tags[tagNum].data :=            0;
  442.     INC(tagNum);
  443.  
  444.     tags[tagNum].tag  :=            T.obSpace;
  445.     tags[tagNum].data :=            T.stNormal;
  446.     INC(tagNum);
  447.  
  448.     tags[tagNum].tag  :=            T.grHoriz;
  449.     tags[tagNum].data :=            T.grPropShare + T.grAlign (*+ T.grCenter*);
  450.     INC(tagNum);
  451.     tags[tagNum].tag  :=              T.obSpace;
  452.     tags[tagNum].data :=              T.stNormal;
  453.     INC(tagNum);
  454.     tags[tagNum].tag  :=              T.obButton;
  455.     tags[tagNum].data :=              0;
  456.     INC(tagNum);
  457.     tags[tagNum].tag  :=              T.atText;
  458.     locStrPtr := L.CatStr(exeN, exeS);
  459.     tags[tagNum].data :=              locStrPtr;
  460.     INC(tagNum);
  461.     tags[tagNum].tag  :=              T.atID;
  462.     tags[tagNum].data :=              exebuttID;
  463.     INC(tagNum);
  464.     tags[tagNum].tag  :=              T.doQuickHelpString;
  465.     locStrPtr := L.CatStr(exeHlpN, exeHlpS);
  466.     tags[tagNum].data :=              locStrPtr;
  467.     INC(tagNum);
  468.     tags[tagNum].tag  :=              T.obSpace;
  469.     tags[tagNum].data :=              T.stSmall;
  470.     INC(tagNum);
  471.     tags[tagNum].tag  :=              T.obButton;
  472.     tags[tagNum].data :=              0;
  473.     INC(tagNum);
  474.     tags[tagNum].tag  :=              T.atText;
  475.     locStrPtr := L.CatStr(newN, newS);
  476.     tags[tagNum].data :=              locStrPtr;
  477.     INC(tagNum);
  478.     tags[tagNum].tag  :=              T.atID;
  479.     tags[tagNum].data :=              newbuttID;
  480.     INC(tagNum);
  481.     tags[tagNum].tag  :=              T.doQuickHelpString;
  482.     locStrPtr := L.CatStr(newHlpN, newHlpS);
  483.     tags[tagNum].data :=              locStrPtr;
  484.     INC(tagNum);
  485.     tags[tagNum].tag  :=              T.obSpace;
  486.     tags[tagNum].data :=              T.stSmall;
  487.     INC(tagNum);
  488.     tags[tagNum].tag  :=              T.obButton;
  489.     tags[tagNum].data :=              0;
  490.     INC(tagNum);
  491.     tags[tagNum].tag  :=              T.atText;
  492.     locStrPtr := L.CatStr(delN, delS);
  493.     tags[tagNum].data :=              locStrPtr;
  494.     INC(tagNum);
  495.     tags[tagNum].tag  :=              T.atID;
  496.     tags[tagNum].data :=              delbuttID;
  497.     INC(tagNum);
  498.     tags[tagNum].tag  :=              T.doQuickHelpString;
  499.     locStrPtr := L.CatStr(delHlpN, delHlpS);
  500.     tags[tagNum].data :=              locStrPtr;
  501.     INC(tagNum);
  502.     tags[tagNum].tag  :=              T.obSpace;
  503.     tags[tagNum].data :=              T.stNormal;
  504.     INC(tagNum);
  505.  
  506.     tags[tagNum].tag  :=            T.grEnd;
  507.     tags[tagNum].data :=            0;
  508.     INC(tagNum);
  509.  
  510.     tags[tagNum].tag  :=            T.obSpace;
  511.     tags[tagNum].data :=            T.stNormal;
  512.     INC(tagNum);
  513.  
  514.     tags[tagNum].tag  :=          T.grEnd;
  515.     tags[tagNum].data :=          0;
  516.     INC(tagNum);
  517.  
  518.     tags[tagNum].tag  :=          T.obSpace;
  519.     tags[tagNum].data :=          T.stNormal;
  520.     INC(tagNum);
  521.  
  522.     tags[tagNum].tag  :=          T.grHoriz;
  523.     tags[tagNum].data :=          T.grPropShare + T.grAlign (*+ T.grCenter*);
  524.     INC(tagNum);
  525.  
  526.     tags[tagNum].tag  :=            T.obButton;
  527.     tags[tagNum].data :=            0;
  528.     INC(tagNum);
  529.     tags[tagNum].tag  :=            T.atText;
  530.     locStrPtr := L.CatStr(savN, savS);
  531.     tags[tagNum].data :=            locStrPtr;
  532.     INC(tagNum);
  533.     tags[tagNum].tag  :=            T.atID;
  534.     tags[tagNum].data :=            savebuttID;
  535.     INC(tagNum);
  536.     tags[tagNum].tag  :=            T.doQuickHelpString;
  537.     locStrPtr := L.CatStr(savHlpN, savHlpS);
  538.     tags[tagNum].data :=            locStrPtr;
  539.     INC(tagNum);
  540.     tags[tagNum].tag  :=            T.obSpace;
  541.     tags[tagNum].data :=            T.stSmall;
  542.     INC(tagNum);
  543.     tags[tagNum].tag  :=            T.obButton;
  544.     tags[tagNum].data :=            0;
  545.     INC(tagNum);
  546.     tags[tagNum].tag  :=            T.atText;
  547.     locStrPtr := L.CatStr(useN, useS);
  548.     tags[tagNum].data :=            locStrPtr;
  549.     INC(tagNum);
  550.     tags[tagNum].tag  :=            T.atID;
  551.     tags[tagNum].data :=            usebuttID;
  552.     INC(tagNum);
  553.     tags[tagNum].tag  :=            T.doQuickHelpString;
  554.     locStrPtr := L.CatStr(useHlpN, useHlpS);
  555.     tags[tagNum].data :=            locStrPtr;
  556.     INC(tagNum);
  557.     tags[tagNum].tag  :=            T.obSpace;
  558.     tags[tagNum].data :=            T.stSmall;
  559.     INC(tagNum);
  560.     tags[tagNum].tag  :=            T.obButton;
  561.     tags[tagNum].data :=            0;
  562.     INC(tagNum);
  563.     tags[tagNum].tag  :=            T.atText;
  564.     locStrPtr := L.CatStr(hidN, hidS);
  565.     tags[tagNum].data :=            locStrPtr;
  566.     INC(tagNum);
  567.     tags[tagNum].tag  :=            T.atID;
  568.     tags[tagNum].data :=            hidebuttID;
  569.     INC(tagNum);
  570.     tags[tagNum].tag  :=            T.doQuickHelpString;
  571.     locStrPtr := L.CatStr(hidHlpN, hidHlpS);
  572.     tags[tagNum].data :=            locStrPtr;
  573.     INC(tagNum);
  574.     tags[tagNum].tag  :=            T.obSpace;
  575.     tags[tagNum].data :=            T.stSmall;
  576.     INC(tagNum);
  577.     tags[tagNum].tag  :=            T.obButton;
  578.     tags[tagNum].data :=            0;
  579.     INC(tagNum);
  580.     tags[tagNum].tag  :=            T.atText;
  581.     locStrPtr := L.CatStr(canN, canS);
  582.     tags[tagNum].data :=            locStrPtr;
  583.     INC(tagNum);
  584.     tags[tagNum].tag  :=            T.atID;
  585.     tags[tagNum].data :=            cancbuttID;
  586.     INC(tagNum);
  587.     tags[tagNum].tag  :=            T.doQuickHelpString;
  588.     locStrPtr := L.CatStr(canHlpN, canHlpS);
  589.     tags[tagNum].data :=            locStrPtr;
  590.     INC(tagNum);
  591.     tags[tagNum].tag  :=          T.grEnd;
  592.     tags[tagNum].data :=          0;
  593.     INC(tagNum);
  594.  
  595.     tags[tagNum].tag  :=          T.obSpace;
  596.     tags[tagNum].data :=          T.stNormal;
  597.     INC(tagNum);
  598.     tags[tagNum].tag  :=        T.grEnd;
  599.     tags[tagNum].data :=        0;
  600.     INC(tagNum);
  601.  
  602.     tags[tagNum].tag  :=        T.obSpace;
  603.     tags[tagNum].data :=        T.stNormal;
  604.     INC(tagNum);
  605.  
  606.     tags[tagNum].tag  :=      T.grEnd;
  607.     tags[tagNum].data :=      0;
  608.     INC(tagNum);
  609.  
  610.     tags[tagNum].tag  :=    T.grEnd;
  611.     tags[tagNum].data :=    0;
  612.     INC(tagNum);
  613.  
  614.     tags[tagNum].tag  :=  T.grEnd;
  615.     tags[tagNum].data :=  0;
  616.     INC(tagNum);
  617.  
  618.     tags[tagNum].tag  :=  U.done;
  619.     tags[tagNum].data :=  0;
  620. END InitGuiTags;
  621.  
  622.  
  623.  
  624.  
  625.  
  626. (* Évite les sys.VAL() sauvages *)
  627. PROCEDURE [0] ConvPtr (p1: sys.ADDRESS ; VAR p2: sys.LONGWORD);
  628. <*$CopyArrays-*>
  629. BEGIN
  630.    p2:=p1
  631. END ConvPtr;
  632.  
  633.  
  634.  
  635.  
  636.  
  637. (* Initialise la liste chaînée à vide *)
  638. PROCEDURE [0] InitHeader ();
  639. <*$CopyArrays-*>
  640. BEGIN
  641.     (* initialisation de l'entête de la liste chaînée *)
  642.     FileListHeader.head := sys.ADR(FileListHeader.tail);
  643.     FileListHeader.tail := NIL;
  644.     FileListHeader.tailPred := sys.ADR(FileListHeader);
  645. END InitHeader;
  646.  
  647.  
  648.  
  649.  
  650.  
  651. (* Écrit size fois la valeur 0 à partir de adr *)
  652. PROCEDURE [0] InitMem (adr: sys.ADDRESS ; size: LONGINT);
  653. <*$CopyArrays-*>
  654. TYPE    memptr = POINTER TO ARRAY OF SHORTINT;
  655. VAR     i : LONGINT;     adr2 : memptr;
  656. BEGIN
  657.     <*$ <IndexChk- *>
  658.     ConvPtr (adr, adr2);
  659.     FOR  i := 0  TO  size-1  DO  adr2[i] := 0  END;
  660.     <*$ > *>
  661. END InitMem;
  662.  
  663.  
  664.  
  665.  
  666.  
  667. (* Lit les tooltypes si l'icône est disponible et remplit la structure TT *)
  668. PROCEDURE [0] GetTT ();
  669. <*$CopyArrays-*>
  670. VAR
  671.     oldDir    : dos.FileLockPtr;
  672.     diskObj   : Workbench.DiskObjectPtr;
  673.     wbMsg     : Workbench.WBStartupPtr;
  674.     tt : E.LSTRPTR;
  675. BEGIN
  676.     TT.Bubbles := FALSE;
  677.     IF  Kernel.fromWorkbench  THEN
  678.         wbMsg := Kernel.WBenchMsg;
  679.  
  680.         (* First CD to the app's directory *)
  681.         oldDir := dos.CurrentDir (wbMsg.argList[0].lock);
  682.         (* Attempt to load the app's icon *)
  683.         diskObj := Icon.GetDiskObject (wbMsg.argList[0].name^);
  684.         IF diskObj # NIL THEN
  685.           tt := Icon.FindToolType (diskObj.toolTypes, TTBubName);
  686.           TT.Bubbles := tt#NIL;
  687.           (* We will free diskObj AFTER we have finished with console. *)
  688.         END;
  689.         (* Back to where we started *)
  690.         oldDir := dos.CurrentDir (oldDir);
  691.  
  692.         IF diskObj # NIL THEN Icon.FreeDiskObject (diskObj) END;
  693.     END;
  694. END GetTT;
  695.  
  696.  
  697.  
  698.  
  699.  
  700. (*
  701. :: Retoune TRUE si la liste entrée en paramètres est vide.  Elle est vide si elle ne contient pas
  702. :: d'éléments à part l'entête.
  703. *)
  704. PROCEDURE [0] listIsEmpty (lst : E.MinListPtr) : BOOLEAN;
  705. <*$CopyArrays-*>
  706. BEGIN
  707.     RETURN  lst.head = sys.ADR(lst.tail)
  708. END listIsEmpty;
  709.  
  710.  
  711.  
  712.  
  713.  
  714. (* Supprime tous les noeuds de la liste et supprime la mémoire associée. *)
  715. (* Il faut être sûr que le contenu n'est plus utilisé *)
  716. PROCEDURE [0] RemAllFileNodes (headerPtr : E.MinListPtr);
  717. <*$CopyArrays-*>
  718. VAR
  719.     nPtr : _FileNodePtr;
  720.     commonNPtr : E.CommonNodePtr;
  721.  
  722. BEGIN
  723.   IF  ~listIsEmpty(sys.ADR(headerPtr))  THEN
  724.     REPEAT
  725.       commonNPtr := E.RemTail (headerPtr^);
  726.       ConvPtr (commonNPtr, nPtr);
  727.  
  728.       (* Supprimer le noeud *)
  729.       sys.DISPOSE (nPtr);
  730.     UNTIL  commonNPtr=NIL;
  731.   END;
  732. END RemAllFileNodes;
  733.  
  734.  
  735.  
  736.  
  737.  
  738. (* Retourne le noeud suivant.  Si nP est le dernier élément de la liste, retourne NIL *)
  739. PROCEDURE [0] getSucc (nP : E.MinNodePtr) : E.MinNodePtr;
  740. <*$CopyArrays-*>
  741. BEGIN
  742.     RETURN  nP.succ
  743. END getSucc;
  744.  
  745.  
  746.  
  747.  
  748.  
  749. (* Met le noeud suivant dans output.  Si nP est le dernier élément de la liste, output vaudra NIL *)
  750. PROCEDURE [0] putSucc (nP : E.MinNodePtr ; VAR output : sys.PTR);
  751. <*$CopyArrays-*>
  752. BEGIN
  753.     output := sys.VAL(sys.PTR, getSucc(nP))
  754. END putSucc;
  755.  
  756.  
  757.  
  758.  
  759.  
  760. (* Met l'entête de la liste dans output. *)
  761. PROCEDURE [0] putHead (mlp : E.MinListPtr ; VAR output : sys.PTR);
  762. <*$CopyArrays-*>
  763. BEGIN
  764.     output := sys.VAL (sys.PTR, mlp.head)
  765. END putHead;
  766.  
  767.  
  768.  
  769.  
  770.  
  771. (* Démarre la notification sur 1 seul fichier seulement si cette notification n'est pas *)
  772. (* déjà démarrée.  Si le démarrage a réussi, l'indique dans not *)
  773. PROCEDURE [0] Notify1 (namePtr : E.LSTRPTR ; VAR not : _notify);
  774. <*$CopyArrays-*>
  775. BEGIN
  776.     IF  ~not.ok  THEN
  777.         InitMem (sys.ADR(not),SIZE(_notify));
  778.  
  779.         not.n.name := namePtr;
  780.         (*  not.n.userData := 0;  *)        (* non-utilisé: inutile de l'initialiser... *)
  781.         not.n.flags := {dos.sendMessage};        (* Réception d'un msg lors d'un évévement *)
  782.         ConvPtr (NotifyMsgPortPtr, not.n.task);   (* port et task sont à la même place... *)
  783.  
  784.         not.ok := dos.StartNotify (not.n);      (* TRUE en cas de succès *)
  785.         <* IF TEST THEN *>
  786.         IF  not.ok  THEN
  787.           dos.PrintF ("%s  %s%s\n", sys.ADR("-->>not.ok = TRUE"), sys.ADR("namePtr^           = "), namePtr);
  788.         ELSE
  789.           dos.PrintF ("%s  %s%s\n", sys.ADR("-->>not.ok = FALSE"), sys.ADR("namePtr^           = "), namePtr);
  790.         END;
  791.         <* END *>
  792.     END;
  793. END Notify1;
  794.  
  795.  
  796.  
  797.  
  798.  
  799. (* Supprime la notification si elle a été démarrée avec succès *)
  800. PROCEDURE [0] StopNotify1 (VAR n : _notify);
  801. <*$CopyArrays-*>
  802. BEGIN
  803.     (* Le test de not.ok est nécessaire, même que dos.EndNotify supporte les cas où *)
  804.     (* dos.StartNotify a échoué.  Si un noeud est rajouté, il n'y a pas forcément tout de *)
  805.     (* suite un dos.StartNotify. La structure dos.NotifyRequest n'est donc pas initialisée. *)
  806.     IF  n.ok  THEN
  807.       dos.EndNotify (n.n);
  808.       n.ok := FALSE
  809.     END;
  810. END StopNotify1;
  811.  
  812.  
  813.  
  814.  
  815.  
  816. (* Supprime le port de message de notification en quittant *)
  817. (* Utiliser Kernel.SetCleanup pour cette procédure *avant* NotifyAllNow (pour que le port *)
  818. (* soit enlevé après la fin de la notification) *)
  819. (* Prend d'éventuels messages restants sur le port *)
  820. PROCEDURE [0] RemNotifyPort (VAR RC:LONGINT);
  821. <*$CopyArrays-*>
  822.  
  823. VAR     NMPtr : dos.NotifyMessagePtr;
  824. BEGIN
  825.     IF  NotifyMsgPortPtr # NIL  THEN
  826.       REPEAT  ConvPtr (E.GetMsg(NotifyMsgPortPtr), NMPtr);
  827.       UNTIL   NMPtr=NIL;
  828.       E.DeleteMsgPort (NotifyMsgPortPtr)
  829.     END
  830. END RemNotifyPort;
  831.  
  832.  
  833.  
  834.  
  835.  
  836. (* Parcourt tous les noeuds et démarre ou arrête la notification suivant la valeur de StartNotify *)
  837. PROCEDURE [0] NotifyAllNow (VAR RC:LONGINT);
  838. <*$CopyArrays-*>
  839.  
  840. CONST   res = 10;                               (* Caractères de réserve pour dos.AddPart *)
  841.         dirnL = SIZE(_path)+SIZE(_name)+res;
  842.  
  843. VAR     nP : _FileNodePtr;
  844.         dirnPtr : E.LSTRPTR;
  845.         short : SHORTINT;
  846.  
  847. BEGIN
  848.     IF  ~listIsEmpty(sys.ADR(FileListHeader))  THEN
  849.  
  850.         putHead (sys.ADR(FileListHeader),nP);
  851.  
  852.         (* pour chaque noeud *)
  853.         WHILE  getSucc(sys.ADR(nP.node)) # NIL  DO
  854.  
  855.             IF  StartNotify  THEN
  856.                 (* Allouer buffer pour chemin + nom de fichier + réserve *)
  857.                 dirnPtr := E.AllocMem (dirnL, {});
  858.                 IF  dirnPtr # NIL  THEN
  859.                     (* créer un nom de fichier avac le chemin complet *)
  860.                     COPY (nP.file.path, dirnPtr^);
  861.                     short := sys.VAL(SHORTINT, dos.AddPart (dirnPtr^, nP.file.name, dirnL));
  862.                     <* IF TEST THEN *>
  863.                     dos.PrintF ("%s%s\n",sys.ADR("dirnPtr           = "), dirnPtr);
  864.                     <* END *>
  865.  
  866.                     (* si la concaténation a réussi, démarrer la notification *)
  867.                     IF  short#0  THEN  Notify1 (dirnPtr, nP.notify)  END;
  868.  
  869.                     (* plus besoin du nom de fichier *)
  870.                     E.FreeMem (dirnPtr, dirnL);
  871.                 END;
  872.             ELSE  StopNotify1 (nP.notify)
  873.             END;
  874.  
  875.             putSucc (sys.ADR(nP.node), nP);
  876.         END;
  877.     END;
  878. END NotifyAllNow;
  879.  
  880.  
  881.  
  882.  
  883.  
  884. (* Appelle NotifiAllNow en mettant Start dans StartNotify *)
  885. (* Met ensuite StartNotify à FALSE pour arrêter la notification en cas de Cleanup *)
  886. PROCEDURE [0] NotifyAll (Start:BOOLEAN);
  887. <*$CopyArrays-*>
  888. VAR     var : LONGINT;
  889. BEGIN
  890.     (* StartNotifyAllNow doit avoir seulement RC comme paramètre, d'où StartNotify global *)
  891.     StartNotify := Start;  NotifyAllNow (var);  StartNotify := FALSE;
  892. END NotifyAll;
  893.  
  894.  
  895.  
  896.  
  897.  
  898. (* Crée une requête à un gadget.  Utilise Intuition/EasyRequest si l'interface n'est pas ouverte *)
  899. (* (pour permettre la fermeture de la triton.library) *)
  900. (* Si l'interface est ouverte, utilise la fonction prévuedans Triton *)
  901. PROCEDURE [0] OneGadReq  (body: ARRAY OF CHAR);
  902. <*$CopyArrays-*>
  903.  
  904. VAR
  905.     trash : E.ULONG;
  906.     tags : ARRAY 3 OF U.TagItem;
  907.  
  908.     EasyStruct : int.EasyStruct; (* Définitions des messages par requête *)
  909.     Result : LONGINT;  (* Résultat de la requête: est toujours 0 puisqu'il n'y a que 1 gadget *)
  910.  
  911. BEGIN
  912.     locStrPtr := L.CatStr(okN, okS);      (* Localisation de 'ok' *)
  913.     IF  guiOpened  THEN
  914.       tags[0].tag  := T.ezTitle;
  915.       tags[0].data := sys.ADR(winTitle);
  916.       tags[1].tag  := T.ezLockProject;    (* La souris sera occupée sur l'interface *)
  917.       tags[1].data := mainProject;
  918.       tags[2].tag  := U.done;
  919.       tags[2].data := 0;
  920.       trash := T.EasyRequest (application, sys.ADR(body), sys.VAL(E.STRPTR, locStrPtr), tags);
  921.     ELSE
  922.       EasyStruct.structSize := 20;            (* Taille de la structure  *)
  923.       EasyStruct.flags := {};                 (* Flags: non-implémenté -> =0  *)
  924.       EasyStruct.title := sys.ADR(winTitle);  (* Titre de la fenêtre  *)
  925.       EasyStruct.textFormat := sys.ADR(body); (* Texte de la fenêtre *)
  926.       EasyStruct.gadgetFormat := locStrPtr;   (* Formatage du textes des gadgets  *)
  927.       Result := int.EasyRequest (NIL, sys.ADR(EasyStruct), NIL, 0);
  928.     END;
  929. END OneGadReq;
  930.  
  931.  
  932.  
  933.  
  934.  
  935. (* Correspond à (1L << sigBit).  Il est nécessaire de multiplier parce que les fonctions de *)
  936. (* décalage posent problème pour le bit n°31 *)
  937. PROCEDURE [0] ComputeSig (sigBit:SHORTINT): SET;
  938. <*$CopyArrays-*>
  939. VAR
  940.     Trash   : SHORTINT;
  941.     Result  : LONGINT;
  942. BEGIN
  943.     Trash := sigBit;
  944.     Result := 1;
  945.     WHILE  Trash>0  DO
  946.       Result := Result*2;        (*  Décaler sigBit fois de 1 bit à gauche  *)
  947.       DEC(Trash);
  948.     END;
  949.     RETURN sys.VAL(SET,Result);
  950. END ComputeSig;
  951.  
  952.  
  953.  
  954.  
  955.  
  956. (* Supprime le broker ou ce qu'il en existe (Prend d'éventuels messages restants sur le port) *)
  957. <*$CopyArrays-*>
  958. PROCEDURE BrokerClose (VAR RC: LONGINT);
  959.  
  960. VAR     BMPtr : E.MessagePtr;
  961. BEGIN
  962.     IF  BrokerPtr # NIL  THEN  com.DeleteCxObjAll(BrokerPtr)  END;
  963.       IF  BrokerPortPtr # NIL  THEN  LOOP
  964.         BMPtr := E.GetMsg(BrokerPortPtr);
  965.         IF  BMPtr=NIL  THEN  EXIT  END;
  966.         E.ReplyMsg (BMPtr)
  967.       END;
  968.       E.DeleteMsgPort(BrokerPortPtr)
  969.     END;
  970. END BrokerClose;
  971.  
  972.  
  973.  
  974.  
  975.  
  976. (* Initialise le broker *)
  977. <*$CopyArrays-*>
  978. PROCEDURE BrokerInit(): BOOLEAN;
  979.  
  980. VAR Ok : BOOLEAN;
  981.     Trash : E.LONGBOOL;
  982.  
  983. BEGIN
  984.     Ok := FALSE;
  985.     BrokerPtr := NIL;
  986.  
  987.     BrokerPortPtr := E.CreateMsgPort();
  988.  
  989.     Kernel.SetCleanup (BrokerClose);
  990.  
  991.     IF  BrokerPortPtr # NIL  THEN
  992.         NewBroker.version := com.nbVersion;
  993.         NewBroker.name :=  sys.ADR(appName);
  994.         NewBroker.title := sys.ADR(winTitle);
  995.         NewBroker.descr := sys.ADR(appTitle);
  996.         NewBroker.unique := sys.VAL(s.SET16,com.unique);
  997.         NewBroker.flags := sys.VAL(s.SET16,com.showHide);
  998.         NewBroker.pri := 0;
  999.         NewBroker.port := BrokerPortPtr;
  1000.  
  1001.         Trash := 0;
  1002.         BrokerPtr := com.CxBroker(NewBroker,Trash);
  1003.  
  1004.         IF  BrokerPtr # NIL  THEN
  1005.             Trash := com.ActivateCxObj(BrokerPtr,1);
  1006.             BrokerWaitSig := ComputeSig(BrokerPortPtr.sigBit);
  1007.             Ok := TRUE;
  1008.         END;
  1009.     END;
  1010.     RETURN Ok;
  1011. END BrokerInit;
  1012.  
  1013.  
  1014.  
  1015.  
  1016.  
  1017. (* Convertit le numéro sélectionné de la liste en pointer sur le neoud correspondant *)
  1018. <*$CopyArrays-*>
  1019. PROCEDURE FindNode (num : LONGINT) : _FileNodePtr;
  1020. VAR     i: E.ULONG;   nP: _FileNodePtr;
  1021. BEGIN
  1022.     putHead (sys.ADR(FileListHeader),nP);
  1023.     FOR  i := 0 TO num-1  DO  putSucc (sys.ADR(nP.node), nP)  END;
  1024.     RETURN nP;
  1025. END FindNode;
  1026.  
  1027.  
  1028.  
  1029.  
  1030.  
  1031. (* Initialise un nouveau noeud de la liste pour utilisation. *)
  1032. <*$CopyArrays-*>
  1033. PROCEDURE InitFileNode (VAR n : _FileNodePtr);
  1034. BEGIN
  1035.     n.node.succ := NIL;
  1036.     n.node.pred := NIL;
  1037.     n.node.type := E.unknown;
  1038.     n.node.pri  := 0;
  1039.     locStrPtr := L.CatStr(emptyN, emptyS);
  1040.     COPY (locStrPtr^, n.file.path);
  1041.     COPY (locStrPtr^, n.file.name);
  1042.     COPY (locStrPtr^, n.file.cmd);
  1043.     n.notify.ok := FALSE;
  1044. END InitFileNode;
  1045.  
  1046.  
  1047.  
  1048.  
  1049.  
  1050. (* Tente d'ouvrir l'interface *)
  1051. <*$CopyArrays-*>
  1052. PROCEDURE OpenGui();
  1053.  
  1054. BEGIN
  1055.     IF  ~guiOpened  THEN
  1056.  
  1057.         T.OpenLib (T.TRITON20VERSION);
  1058.  
  1059.         IF  T.base # NIL  THEN
  1060.             application := T.CreateAppTags (
  1061.                T.caName, sys.ADR(appName),
  1062.                T.caLongName, sys.ADR(appName),
  1063.                T.caRelease, sys.ADR("1.0"),
  1064.                T.caVersion, sys.ADR("38.0"),
  1065.                T.caInfo, sys.ADR(appTitle),
  1066.                T.caDate, sys.ADR("31.03.97"),
  1067.                U.done
  1068.             );
  1069.  
  1070.             IF application # NIL THEN
  1071.                 <* IF TEST THEN *>
  1072.                 dos.PrintF ("application créée\n",NIL);
  1073.                 <* END *>
  1074.                 mainProject := T.OpenProject (application, projTagsPtr^);
  1075.  
  1076.                 IF  mainProject # NIL  THEN  guiOpened := TRUE  END;
  1077.                 <* IF TEST THEN *>
  1078.                 ; dos.PrintF ("%s\n",sys.ADR("projet créé"));
  1079.                 <* END *>
  1080.             END;
  1081.  
  1082.             IF  ~guiOpened  THEN
  1083.               locStrPtr := L.CatStr(noTrIntN, noTrIntS);    OneGadReq (locStrPtr^);
  1084.             END;
  1085.  
  1086.         ELSE
  1087.             locStrPtr := L.CatStr(noTrLibN, noTrLibS);    OneGadReq (locStrPtr^);
  1088.         END;
  1089.     END;
  1090.  
  1091. END OpenGui;
  1092.  
  1093.  
  1094.  
  1095.  
  1096.  
  1097. (* Ferme l'interface si elle est ouverte. (Est appelé automatiquement en quittant) *)
  1098. <*$CopyArrays-*>
  1099. PROCEDURE CloseGuiNow (VAR RC: LONGINT);
  1100. VAR     msgPtr : T.MessagePtr;
  1101. BEGIN
  1102.     IF  guiOpened  THEN  LOOP
  1103.       msgPtr := T.GetMsg (application);
  1104.       IF  msgPtr = NIL  THEN  EXIT  END;
  1105.       T.ReplyMsg (msgPtr)
  1106.     END  END;
  1107.  
  1108.     IF  mainProject # NIL  THEN
  1109.       T.CloseProject (mainProject);   mainProject := NIL
  1110.     END;
  1111.  
  1112.     IF  application # NIL  THEN
  1113.       T.DeleteApp (application);   application := NIL
  1114.     END;
  1115.  
  1116.     guiOpened := FALSE
  1117.  
  1118.     <* IF TEST THEN *>
  1119.     ; dos.PrintF ("%s\n",sys.ADR("fermeture"));
  1120.     <* END *>
  1121. END CloseGuiNow;
  1122.  
  1123.  
  1124.  
  1125.  
  1126.  
  1127. (* Ferme l'interface si elle est ouverte. *)
  1128. <*$CopyArrays-*>
  1129. PROCEDURE CloseGui ();
  1130. VAR     var : LONGINT;
  1131. BEGIN
  1132.     CloseGuiNow (var);
  1133.     T.CloseLib ();
  1134. END CloseGui;
  1135.  
  1136.  
  1137.  
  1138.  
  1139.  
  1140. (* Ferme l'interface si elle est ouverte. *)
  1141. <*$CopyArrays-*>
  1142. PROCEDURE SetlvName (VAR nP : _FileNodePtr);
  1143. BEGIN
  1144.     (* si la notification est sur un dir, afficher le dir dans le listview, sinon le fichier *)
  1145.     IF  nP.file.name[0] = "\0"  THEN
  1146.       nP.node.name := sys.ADR(nP.file.path)
  1147.     ELSE
  1148.       nP.node.name := sys.ADR(nP.file.name)
  1149.     END;
  1150. END SetlvName;
  1151.  
  1152.  
  1153.  
  1154.  
  1155.  
  1156. (*
  1157. :: Requête de fichier Asl
  1158. :: L'ouverture et la fermeture de la asl.library est implémentée.
  1159. :: path, file : pointeur sur la chaîne de caractère où stocker le chemin ou le nom de fichier
  1160. :: sizep, sizef : indique la longueur maxi à ne pas dépasser de path et file
  1161. :: Si file = NIL le chemin et le nom de fichier seront concaténés dans path
  1162. *)
  1163. <*$CopyArrays-*>
  1164. PROCEDURE AslReq (path, file : E.LSTRPTR ; sizep, sizef : LONGINT ; titlePtr : E.LSTRPTR);
  1165.  
  1166. VAR
  1167.     AslPTags  : ARRAY 2 OF U.TagItem;
  1168.     AslReqPtr : asl.FileRequesterPtr;
  1169.  
  1170. BEGIN
  1171.     asl.OpenLib ();
  1172.     IF  asl.base # NIL  THEN
  1173.  
  1174.       AslPTags[0].tag := U.done;
  1175.       ConvPtr (asl.AllocAslRequest (asl.fileRequest, AslPTags), AslReqPtr);
  1176.  
  1177.       IF  AslReqPtr # NIL  THEN
  1178.         AslPTags[0].tag := asl.hail;
  1179.         AslPTags[0].data := titlePtr;
  1180.         AslPTags[1].tag := U.done;  (* asl.dir; *)
  1181.         AslPTags[1].data := 0;
  1182.  
  1183.         IF  asl.AslRequest (AslReqPtr, AslPTags)  THEN
  1184.  
  1185.           IF  file # NIL  THEN
  1186.             sys.MOVE (AslReqPtr.drawer, path, 1+Util.MinLongint (str.Length(AslReqPtr.drawer^),sizep-1));
  1187.             sys.MOVE (AslReqPtr.file, file, 1+Util.MinLongint(str.Length(AslReqPtr.file^),sizef-1));
  1188.           ELSE
  1189.             sys.MOVE (AslReqPtr.drawer, path, 1+Util.MinLongint(str.Length(AslReqPtr.drawer^),sizep-1));
  1190.             IF  dos.AddPart (path^, AslReqPtr.file^, sizep)  THEN END;
  1191.           END;
  1192.           <* IF TEST THEN *>
  1193.           dos.PrintF ("  %s%s\n  %s%s\n  %s%s\n", sys.ADR("AslReqPtr.drawer           = "), AslReqPtr.drawer, sys.ADR("AslReqPtr.file           = "), AslReqPtr.file, sys.ADR("path           = "), path);
  1194.           <* END *>
  1195.         END;
  1196.         asl.FreeAslRequest (AslReqPtr);
  1197.       END;
  1198.  
  1199.       asl.CloseLib ();
  1200.     ELSE
  1201.       locStrPtr := L.CatStr(noAslLibN, noAslLibS);    OneGadReq (locStrPtr^);
  1202.     END;
  1203. END AslReq;
  1204.  
  1205.  
  1206.  
  1207.  
  1208.  
  1209. (*
  1210. :: retourne TRUE si la config a pu être lue et la liste chaînée correctement
  1211. :: mise à jour.  En cas de manque de mémoire, lit le fichier en partie seulement
  1212. *)
  1213. <*$CopyArrays-*>
  1214. PROCEDURE LoadConfig (headerPtr : E.MinListPtr) : BOOLEAN;
  1215. (* le pointeur est nécessaire pour ne pas prendre l'adresse du paramètre ! *)
  1216. (* (il faut demander l'adresse de la chaîne avant l'entrée dans la proc...) *)
  1217.  
  1218. VAR
  1219.     CommonNodePtr : E.CommonNodePtr;        (* var temp... *)
  1220.     FileNodePtr  : _FileNodePtr;            (* un élément de la liste *)
  1221.     FileHandlePtr : dos.FileHandlePtr;
  1222.     shortint : SHORTINT;   (* Vérif du numéro de version *)
  1223.     RealLength : LONGINT;                   (* longueur effectivement lue *)
  1224.     ok : BOOLEAN;
  1225.  
  1226. BEGIN
  1227.     ok := FALSE;
  1228.  
  1229.     FileHandlePtr := dos.Open (configLName, dos.oldFile);
  1230.  
  1231.     IF  FileHandlePtr # NIL  THEN
  1232.  
  1233.         (* pas d'err jusqu'à nouvel avis *)
  1234.         ok := TRUE;
  1235.  
  1236.         (* Lire numéro de version *)
  1237.         RealLength := dos.Read (FileHandlePtr, shortint, 1);
  1238.  
  1239.         (* Si le numéro a pu être lu et la version correspond *)
  1240.         IF  (RealLength = 1) & (shortint = internalVer)  THEN
  1241.  
  1242.            REPEAT
  1243.  
  1244.                RealLength := 0;
  1245.  
  1246.                (* libération en quittant *)
  1247.                NEW (FileNodePtr);
  1248.  
  1249.                IF  FileNodePtr # NIL  THEN
  1250.  
  1251.                    InitFileNode (FileNodePtr);
  1252.  
  1253.                    (* lecture de l'entrée suivante *)
  1254.  
  1255.                    RealLength := dos.Read (FileHandlePtr, FileNodePtr.file, SIZE(_File));
  1256.  
  1257.                    (* si la longueur est juste, on remplit le neoud *)
  1258.                    (* si la longueur n'est pas juste, on a atteint la fin *)
  1259.                    (* du fichier ou le fichier est corrompu. *)
  1260.                    IF  RealLength = SIZE(_File)  THEN
  1261.                        SetlvName (FileNodePtr);
  1262.  
  1263.                        (* ajout du noeud en fin de liste *)
  1264.                        E.AddTail (headerPtr^, sys.VAL(E.CommonNodePtr, FileNodePtr));
  1265.                    ELSE
  1266.                        sys.DISPOSE (FileNodePtr);
  1267.                        IF  RealLength # 0  THEN
  1268.  
  1269.                          (* Supprimer les noeuds existants *)
  1270.                          RemAllFileNodes (headerPtr);
  1271.  
  1272.                          <* IF TEST THEN *>
  1273.                          dos.PrintF ("%s\n",sys.ADR("fichier corrompu"));
  1274.                          <* END *>
  1275.                          (* fichier corrompu: le nombre d'enregistrements n'est pas entier *)
  1276.                          locStrPtr := L.CatStr(prfCrptN, prfCrptS);    OneGadReq (locStrPtr^);
  1277.  
  1278.                          ok := FALSE
  1279.                        END;
  1280.                    END;
  1281.  
  1282.                ELSE
  1283.                    (* manque de ram pour charger la cfg *)
  1284.                    <* IF TEST THEN *>
  1285.                    dos.PrintF ("%s\n",sys.ADR("manque de ram"));
  1286.                    <* END *>
  1287.                    ok := FALSE
  1288.                END;
  1289.  
  1290.            (* jusqu'au dernier rec *)
  1291.            UNTIL  RealLength # SIZE(_File);
  1292.  
  1293.         ELSE
  1294.           ok := FALSE;
  1295.           locStrPtr := L.CatStr(prfCrptN, prfCrptS);    OneGadReq (locStrPtr^);
  1296.         END;  (*  if (RealLength=1) & (shortint=internalVer)  *)
  1297.  
  1298.         dos.OldClose (FileHandlePtr);
  1299.  
  1300.     END;
  1301.     RETURN ok;
  1302. END LoadConfig;
  1303.  
  1304.  
  1305.  
  1306.  
  1307.  
  1308.  
  1309. (*
  1310. :: retourne TRUE si la config a pu être sauvée.
  1311. *)
  1312. <*$CopyArrays-*>
  1313. PROCEDURE SaveConfig (headerPtr : E.MinListPtr;  Envarc: BOOLEAN) : BOOLEAN;
  1314. (* le pointeur est nécessaire pour ne pas prendre l'adresse du paramètre ! *)
  1315. (* (il faut demander l'adresse de la chaîne avant l'entrée dans la proc...) *)
  1316.  
  1317. VAR
  1318.     FileNodePtr  : _FileNodePtr;            (* un élément de la liste *)
  1319.     FileNodePtr2 : _FileNodePtr;            (* un élément de la liste *)
  1320.     FileHandlePtr : dos.FileHandlePtr;
  1321.     shortint : SHORTINT;   (* Enregistrement du numéro de version *)
  1322.     RealLength : LONGINT;                   (* longueur effectivement lue *)
  1323.     ok : BOOLEAN;
  1324.     cfgName : POINTER TO ARRAY OF CHAR;
  1325.  
  1326. BEGIN
  1327.     ok := FALSE;
  1328.  
  1329.     (* sélection Env: Envarc: *)
  1330.     sys.PUT (sys.ADR(cfgName),sys.ADR(configLName));
  1331.     IF Envarc THEN  sys.PUT(sys.ADR(cfgName),sys.ADR(configSName))  END;
  1332.  
  1333.     FileHandlePtr := dos.Open (cfgName^, dos.newFile);
  1334.  
  1335.     IF  FileHandlePtr # NIL  THEN
  1336.  
  1337.         (* pas d'err jusqu'à nouvel avis *)
  1338.         ok := TRUE;
  1339.  
  1340.         (* écriture du numéro de version *)
  1341.         shortint := internalVer;
  1342.         RealLength := dos.Write (FileHandlePtr, shortint, 1);
  1343.  
  1344.         (* Si l'écriture a fonctionné, continuer *)
  1345.         IF  RealLength = 1  THEN
  1346.  
  1347.             (* pointer sur 1er noeud *)
  1348.             putHead (headerPtr, FileNodePtr);
  1349.  
  1350.             (* pour chaque noeud *)
  1351.             LOOP
  1352.                 putSucc (sys.ADR(FileNodePtr.node), FileNodePtr2);
  1353.  
  1354.                 IF  FileNodePtr2 = NIL  THEN  EXIT  END;
  1355.  
  1356.                 (* écriture de l'entrée suivante *)
  1357.                 RealLength := dos.Write (FileHandlePtr, FileNodePtr.file, SIZE(_File));
  1358.  
  1359.                 (* arrêter écriture en cas d'erreur *)
  1360.                 IF  RealLength # SIZE(_File)  THEN
  1361.                   <* IF TEST THEN *>
  1362.                   dos.PrintF ("%s\n",sys.ADR("err de fichier en écriture"));
  1363.                   <* END *>
  1364.                   locStrPtr := L.CatStr(cfgSErrN, cfgSErrS);    OneGadReq (locStrPtr^);
  1365.                   ok := FALSE;
  1366.                   EXIT;
  1367.                 END;
  1368.  
  1369.                 (* noeud suivant *)
  1370.                 FileNodePtr := FileNodePtr2;
  1371.             END;
  1372.  
  1373.         ELSE
  1374.           ok := FALSE;
  1375.           locStrPtr := L.CatStr(cfgSErrN, cfgSErrS);    OneGadReq (locStrPtr^);
  1376.         END;  (*  if (RealLength=1)  *)
  1377.  
  1378.         dos.OldClose (FileHandlePtr);
  1379.  
  1380.     END;
  1381.     RETURN ok;
  1382. END SaveConfig;
  1383.  
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389. <*$CopyArrays-*>
  1390. PROCEDURE ManageGui (Open : BOOLEAN);
  1391. (*  Ouvre l'interface immédiatement si Open  *)
  1392.  
  1393.  
  1394.  
  1395. VAR
  1396.     signals : SET;
  1397.     messagePtr : T.MessagePtr;
  1398.  
  1399.     eventID     : E.ULONG;
  1400.     eventclass  : E.ULONG;
  1401.     eventcode   : E.ULONG;
  1402.     eventdata   : E.ULONG;
  1403.  
  1404.     quit : BOOLEAN;
  1405.  
  1406.     BrokerMsgPtr : E.MessagePtr;
  1407.     BrokerMsgType : SET;
  1408.     BrokerMsgID : LONGINT;
  1409.  
  1410.     lstrptr : E.LSTRPTR;
  1411.     longbool : E.LONGBOOL;
  1412.  
  1413.     nodePtr : _FileNodePtr;            (*  rajout d'un noeud dans la liste (New)  *)
  1414.     commonNodePtr : E.CommonNodePtr;   (*  pour la suppression des enregistrements  *)
  1415.  
  1416.     NotifyMsgPtr : dos.NotifyMessagePtr;
  1417.  
  1418.     ctrlCWaitSig : SET;        (* bit à attendre pour recevoir le control-c *)
  1419.  
  1420.  
  1421.  
  1422.  
  1423.     (* Met à jour les 2 string gadgets en fonction de l'entrée sélectionnée *)
  1424.     (* Si la liste est vide, ombre ces deux gadgets *)
  1425.     <*$CopyArrays-*>
  1426.     PROCEDURE UpdateStrGetfGads (selected : E.ULONG);
  1427.  
  1428.     VAR
  1429.         nodePtr : _FileNodePtr;   (* ne pas confondre avec l'autre *)
  1430.  
  1431.     BEGIN
  1432.         (* S'il existe au moins un noeud *)
  1433.         IF  ~listIsEmpty(sys.ADR(FileListHeader))  THEN
  1434.  
  1435.           (* faire pointer nodePtr sur l'entrée sélectionnée *)
  1436.           nodePtr := FindNode (selected);
  1437.  
  1438.           (* Il y a au moins une entrée; activer les gadgets *)
  1439.           T.SetAttribute (mainProject, fileStrID, T.atDisabled, 0);
  1440.           T.SetAttribute (mainProject, exeStrID, T.atDisabled, 0);
  1441.           T.SetAttribute (mainProject, pathStrID, T.atDisabled, 0);
  1442.           T.SetAttribute (mainProject, getffileID, T.atDisabled, 0);
  1443.           T.SetAttribute (mainProject, getfexeID, T.atDisabled, 0);
  1444.  
  1445.           (* mettre à jour les string gadgets d'après l'entrée sélectionnée dans le lv *)
  1446.           T.SetAttribute (mainProject, pathStrID, 0, sys.ADR(nodePtr.file.path));
  1447.           T.SetAttribute (mainProject, fileStrID, 0, sys.ADR(nodePtr.file.name));
  1448.           T.SetAttribute (mainProject, exeStrID, 0, sys.ADR(nodePtr.file.cmd));
  1449.  
  1450.         ELSE
  1451.           (* aucune entree dans la liste: désactiver les string-gadgets et les getfiles. *)
  1452.           T.SetAttribute (mainProject, getffileID, T.atDisabled, 1);
  1453.           T.SetAttribute (mainProject, getfexeID, T.atDisabled, 1);
  1454.           T.SetAttribute (mainProject, pathStrID, T.atDisabled, 1);
  1455.           T.SetAttribute (mainProject, fileStrID, T.atDisabled, 1);
  1456.           T.SetAttribute (mainProject, exeStrID, T.atDisabled, 1);
  1457.         END;
  1458.     END UpdateStrGetfGads;
  1459.  
  1460.  
  1461.  
  1462.  
  1463.     (* Sauve le contenu des string gadgets *)
  1464.     <*$CopyArrays-*>
  1465.     PROCEDURE SaveStrGads (selected : E.ULONG);
  1466.  
  1467.     VAR
  1468.         nodePtr : _FileNodePtr;   (* ne pas confondre avec l'autre *)
  1469.         lstrptr  : E.LSTRPTR;
  1470.         lstrptr2 : E.LSTRPTR;
  1471.         ulong : E.ULONG;
  1472.  
  1473.     BEGIN
  1474.         (* S'il existe au moins un noeud *)
  1475.         IF  ~listIsEmpty(sys.ADR(FileListHeader))  THEN
  1476.  
  1477.           (* faire pointer nodePtr sur l'entrée sélectionnée *)
  1478.           nodePtr := FindNode (selected);
  1479.  
  1480.  
  1481.           locStrPtr := L.CatStr(emptyN, emptyS);
  1482.           lstrptr := sys.VAL (E.LSTRPTR, T.GetAttribute (mainProject, pathStrID, 0));
  1483.           COPY (lstrptr^, nodePtr.file.path);
  1484.           <* IF TEST THEN *>
  1485.           IF  nodePtr.file.path[0]           = "\0"  THEN
  1486.             COPY (locStrPtr^, nodePtr.file.path);
  1487.           END;
  1488.           <* END *>
  1489.  
  1490.           (* Déterminer s'il existe un chemin *)
  1491.           lstrptr := sys.VAL (E.LSTRPTR, T.GetAttribute (mainProject, fileStrID, 0));
  1492.           COPY (lstrptr^, nodePtr.file.name);
  1493.           <* IF TEST THEN *>
  1494.           dos.PrintF ("%s%s\n", sys.ADR("-->>Path updaté : path           = "), sys.ADR(nodePtr.file.path));
  1495.           <* END *>
  1496.  
  1497.           lstrptr := sys.VAL (E.LSTRPTR, T.GetAttribute (mainProject, exeStrID, 0));
  1498.           COPY (lstrptr^, nodePtr.file.cmd);
  1499.           <* IF TEST THEN *>
  1500.           IF  nodePtr.file.cmd[0]           = "\0"  THEN
  1501.             COPY (locStrPtr^, nodePtr.file.cmd);
  1502.           END;
  1503.           <* END *>
  1504.  
  1505.           SetlvName (nodePtr);
  1506.         END;
  1507.     END SaveStrGads;
  1508.  
  1509.  
  1510.  
  1511.  
  1512.     (* Met à jour les 2 string gadgets en fonction de l'entrée sélectionnée *)
  1513.     (* Si la liste est vide, ombre ces deux gadgets *)
  1514.     <*$CopyArrays-*>
  1515.     PROCEDURE Execute (fP : _FilePtr);
  1516.  
  1517.     CONST   run           = "Run <nil:  ";   runsize = 12;
  1518.     VAR     cmdLinePtr : E.LSTRPTR;
  1519.  
  1520.     BEGIN
  1521.       (* Si la commande existe *)
  1522.       IF  fP.cmd[0] # "\0"  THEN
  1523.  
  1524.         (* Allocation de place pour la commande. *)
  1525.         cmdLinePtr := E.AllocMem (SIZE(_cmd)+runsize, {});
  1526.  
  1527.         IF  cmdLinePtr # NIL  THEN
  1528.           (* La commande est lancée en tâche de fond. *)
  1529.           (* La sortie est dirigée vers nil sauf si la commande la redirige *)
  1530.           COPY (run, cmdLinePtr^);
  1531.  
  1532.           (* Copie de la commande après le "Run <nil:  " *)
  1533.           sys.MOVE (sys.ADR(fP.cmd), sys.VAL(LONGINT,cmdLinePtr)+runsize-1, LEN(fP.cmd));
  1534.  
  1535.           <* IF TEST THEN *>
  1536.           dos.PrintF ("%s%s\n",sys.ADR("cmdLinePtr^           = "), cmdLinePtr);
  1537.           <* END *>
  1538.  
  1539.           (* Exécution de la commande *)
  1540.           IF  ~dos.Execute (cmdLinePtr^, NIL, dos.Output())  THEN
  1541.             (* Message si la commande ne peut pas être lancée *)
  1542.             locStrPtr := L.CatStr(exeErrN, exeErrS);    OneGadReq (locStrPtr^);
  1543.           END;
  1544.  
  1545.           (* Libération de la mémoire de la commande *)
  1546.           E.FreeMem (cmdLinePtr, SIZE(_cmd)+runsize);
  1547.         END;
  1548.       END;
  1549.     END Execute;
  1550.  
  1551.  
  1552.  
  1553.  
  1554. BEGIN   (*  ManageGui  *)
  1555.  
  1556.  
  1557.     mainProject := NIL;
  1558.     application := NIL;
  1559.     guiOpened := FALSE;
  1560.  
  1561.     Kernel.SetCleanup (CloseGuiNow);
  1562.  
  1563.     actlvID := 0;        (* devra être initialisé par LoadConfig *)
  1564.  
  1565.     ctrlCWaitSig := ComputeSig (dos.ctrlC);
  1566.  
  1567.     quit := FALSE;
  1568.  
  1569.  
  1570.     IF  Open  THEN
  1571.       OpenGui();
  1572.       IF  guiOpened  THEN
  1573.         T.SetAttribute (mainProject, lvID, T.atValue, actlvID);
  1574.         UpdateStrGetfGads (actlvID);
  1575.       ELSE
  1576.         quit := TRUE;
  1577.       END;
  1578.     END;
  1579.  
  1580.  
  1581.  
  1582.  
  1583.     WHILE  ~quit  DO
  1584.  
  1585.  
  1586.         (* Fenêtre ouverte: fonction d'attente de trition *)
  1587.         IF  guiOpened  THEN
  1588.           signals := sys.VAL(SET, T.Wait(application, sys.VAL(E.ULONG,BrokerWaitSig+NotifyWaitSig+ctrlCWaitSig)));
  1589.           <* IF TEST THEN *>
  1590.           (* dos.PrintF ("%s%lx\n",sys.ADR("signaux reçus = $"), signals); *)
  1591.           <* END *>
  1592.         ELSE  signals := E.Wait (BrokerWaitSig+NotifyWaitSig+ctrlCWaitSig)
  1593.         END;
  1594.  
  1595.  
  1596.  
  1597.         IF  ctrlCWaitSig = ctrlCWaitSig*signals  THEN
  1598.           <* IF TEST THEN *>
  1599.           dos.PrintF ("%s", sys.ADR("dos.CtrlC\n"));
  1600.           <* END *>
  1601.           quit := TRUE;
  1602.         END;
  1603.  
  1604.  
  1605.  
  1606.         (* Signaux reçus des notifications *)
  1607.         IF  NotifyWaitSig = NotifyWaitSig*signals  THEN
  1608.             LOOP
  1609.                 ConvPtr (E.GetMsg(NotifyMsgPortPtr), NotifyMsgPtr);
  1610.  
  1611.                 IF  NotifyMsgPtr=NIL  THEN  EXIT  END;
  1612.  
  1613.                 <* IF TEST THEN *>
  1614.                 dos.PrintF ("%s%lx\n", sys.ADR("===>>>NotifyMsgPtr = $"), NotifyMsgPtr);
  1615.                 <* END *>
  1616.  
  1617.                 IF  listIsEmpty(sys.ADR(FileListHeader))  THEN  EXIT  END;
  1618.  
  1619.                 putHead (sys.ADR(FileListHeader), nodePtr);
  1620.  
  1621.                 WHILE  (getSucc(sys.ADR(nodePtr.node)) # NIL)  &  (NotifyMsgPtr.nReq # sys.ADR(nodePtr.notify.n))
  1622.                 DO  putSucc (sys.ADR(nodePtr.node), nodePtr)  END;
  1623.  
  1624.                 <* IF TEST THEN *>
  1625.                 ; dos.PrintF ("%s %s %s\n", sys.ADR("-->>"), sys.ADR(nodePtr.file.name), sys.ADR(nodePtr.file.cmd));
  1626.                 <* END *>
  1627.  
  1628.                 (* Exécuter la commande contenue dans le noeud *)
  1629.                 Execute (sys.VAL(_FilePtr, sys.ADR(nodePtr.file)));
  1630.             END;  (* loop *)
  1631.         END;   (*  IF  NotifyWaitSig = NotifyWaitSig*signals  THEN  *)
  1632.  
  1633.  
  1634.  
  1635.  
  1636.         (* Signaux reçus des commodités *)
  1637.         IF  BrokerWaitSig = BrokerWaitSig*signals  THEN
  1638.  
  1639.             LOOP
  1640.                 BrokerMsgPtr := E.GetMsg(BrokerPortPtr);
  1641.  
  1642.                 IF  BrokerMsgPtr=NIL  THEN  EXIT  END;
  1643.  
  1644.                 BrokerMsgType := com.CxMsgType(sys.VAL(com.CxMsgPtr,BrokerMsgPtr));
  1645.                 BrokerMsgID := com.CxMsgID(sys.VAL(com.CxMsgPtr,BrokerMsgPtr));
  1646.  
  1647.                 E.ReplyMsg (BrokerMsgPtr);
  1648.  
  1649.                 IF  BrokerMsgType=sys.VAL(SET,com.cxmCommand)  THEN
  1650.                     CASE  BrokerMsgID  OF
  1651.                       com.cmdDisappear:
  1652.                         CloseGui ();
  1653.                         <* IF TEST THEN *>
  1654.                         dos.PrintF ("%s", sys.ADR("Hide\n"));
  1655.                         <* END *>
  1656.                         |
  1657.                       com.cmdAppear:
  1658.                         OpenGui();
  1659.                         IF  guiOpened  THEN
  1660.                           T.SetAttribute (mainProject, lvID, T.atValue, actlvID);
  1661.                           UpdateStrGetfGads (actlvID);
  1662.                         END;
  1663.                         <* IF TEST THEN *>
  1664.                         dos.PrintF ("%s", sys.ADR("Show\n"));
  1665.                         <* END *>
  1666.                         |
  1667.                       com.cmdDisable:
  1668.                         longbool := com.ActivateCxObj(BrokerPtr,0);
  1669.                         NotifyAll (FALSE);
  1670.                         |
  1671.                       com.cmdEnable:
  1672.                         longbool := com.ActivateCxObj(BrokerPtr,1);
  1673.                         NotifyAll (TRUE);
  1674.                         |
  1675.                       com.cmdKill:
  1676.                         <* IF TEST THEN *>
  1677.                         dos.PrintF ("%s", sys.ADR("Kill\n"));
  1678.                         <* END *>
  1679.                         quit := TRUE;
  1680.                     ELSE    (*  CASE  (BrokerMsgID)  OF  *)
  1681.                         <* IF TEST THEN *>
  1682.                         dos.PrintF ("%s", sys.ADR(">>>>>>>>  ManageGui: Unknown Broker ID  <<<<<<<<<\n"));
  1683.                         <* END *>
  1684.  
  1685.                     END;    (*  CASE  (BrokerMsgID)  OF  *)
  1686.  
  1687.                 END;    (*  IF  (BrokerMsgType=com.mCommand)  *)
  1688.  
  1689.             END;    (*  LOOP  *)
  1690.  
  1691.         END;   (*  IF BrokerWaitSig = BrokerWaitSig*signals  *)
  1692.  
  1693.  
  1694.  
  1695.         (* test du message reçu de Triton *)
  1696.         (* On ne sait pas de quel(s) bit(s) de signal il s'agit: on teste le msg à chaque fois *)
  1697.         LOOP
  1698.  
  1699.             IF  ~guiOpened  THEN  EXIT  END;
  1700.  
  1701.             messagePtr := T.GetMsg (application);
  1702.  
  1703.             IF  messagePtr = NIL  THEN  EXIT  END;
  1704.  
  1705.             <* IF TEST THEN *>
  1706.             dos.PrintF ("%s%lx\n",sys.ADR("messagePtr = $"), messagePtr);
  1707.             <* END *>
  1708.  
  1709.             IF  messagePtr.project = mainProject  THEN
  1710.  
  1711.               <* IF TEST THEN *>
  1712.               dos.PrintF (
  1713.                 "%s%-lx\n"
  1714.                 "%s%-lx\n"
  1715.                 "%s%-ld\n"
  1716.                 "%s%-lx\n"
  1717.                 "%s%-lx\n"
  1718.                 "%s%-lx\n"
  1719.                 "%s%-lx\n"
  1720.                 "%s%-ld\n"
  1721.                 "%s%-ld\n"
  1722.                 "%s%-lx\n"
  1723.                 "%s%-lx\n",
  1724.                 sys.ADR("mainProject          = $"), mainProject,
  1725.                 sys.ADR("messagePtr.project   = $"), messagePtr.project,
  1726.                 sys.ADR("messagePtr.ID        =  "), messagePtr.id,
  1727.                 sys.ADR("messagePtr.class     = $"), messagePtr.class,
  1728.                 sys.ADR("messagePtr.data      = $"), messagePtr.data,
  1729.                 sys.ADR("messagePtr.code      = $"), messagePtr.code,
  1730.                 sys.ADR("messagePtr.qualifier = $"), messagePtr.qualifier,
  1731.                 sys.ADR("messagePtr.seconds   =  "), messagePtr.seconds,
  1732.                 sys.ADR("messagePtr.micros    =  "), messagePtr.micros,
  1733.                 sys.ADR("application          = $"), application,
  1734.                 sys.ADR("messagePtr.app       = $"), messagePtr.app);
  1735.               <* END *>
  1736.  
  1737.               eventID := messagePtr.id;
  1738.               eventclass := messagePtr.class;
  1739.               eventcode := messagePtr.code;
  1740.               eventdata := messagePtr.data;
  1741.  
  1742.               T.ReplyMsg (messagePtr);
  1743.               <* IF TEST THEN *>
  1744.               dos.PrintF ("%s\n",sys.ADR("message retourné"));
  1745.               <* END *>
  1746.  
  1747.  
  1748.               CASE  eventclass  OF
  1749.  
  1750.               (* équivalent à Hide *)
  1751.                 T.msCloseWindow:
  1752.                   CloseGui ();
  1753.  
  1754.  
  1755.               (* action ou modification des gadgets *)
  1756.               | T.msAction, T.msNewValue:
  1757.  
  1758.  
  1759.                   (* Suivant gadget affecté *)
  1760.                   CASE  eventID  OF
  1761.  
  1762.  
  1763.                     (* Sélection d'un élément de la liste *)
  1764.                     lvID:
  1765.                       <* IF TEST THEN *>
  1766.                       dos.PrintF ("%s\n",sys.ADR("-->lv"));
  1767.                       <* END *>
  1768.  
  1769.                       (* stocker les modifs dans les strings *)
  1770.                       SaveStrGads (actlvID);
  1771.  
  1772.                       <* IF TEST THEN *>
  1773.                       dos.PrintF ("%s%ld\n",sys.ADR("eventdata           = "), eventdata);
  1774.                       <* END *>
  1775.  
  1776.                       (* stocker nouvelle sélection *)
  1777.                       actlvID := eventdata;
  1778.  
  1779.                       (* mettre à jour gadget pour la nouvelle sélection *)
  1780.                       UpdateStrGetfGads (eventdata);
  1781.  
  1782.  
  1783.                   (* modification à la main du chemin du fichier *)
  1784.                   | pathStrID, fileStrID:
  1785.  
  1786.                       (* stocker les modifs dans les strings *)
  1787.                       SaveStrGads (actlvID);
  1788.  
  1789.                       (* mettre à jour gadget listview *)
  1790.                       T.SetAttribute (mainProject, lvID, 0, sys.VAL(E.ULONG,sys.ADR(FileListHeader)));
  1791.  
  1792.                       (* Mettre à jour strings.  p.ex.: Temp:aa/bb -> bb *)
  1793.                       UpdateStrGetfGads (actlvID);
  1794.  
  1795.  
  1796.                   (* Requête de fichier pour le fichier ou la commande *)
  1797.                   | getffileID, getfexeID:
  1798.  
  1799.                       (* Rechercher position de la sélection actuelle *)
  1800.                       nodePtr := FindNode(actlvID);
  1801.  
  1802.                       (* Demander nouveau ficher *)
  1803.                       T.LockProject (mainProject);
  1804.                       IF  eventID = getffileID  THEN
  1805.                         AslReq (sys.ADR(nodePtr.file.path), sys.ADR(nodePtr.file.name), SIZE(_path), SIZE(_name), sys.ADR(winTitle));
  1806.                       ELSE
  1807.                         AslReq (sys.ADR(nodePtr.file.cmd), NIL, SIZE(_cmd), 0, sys.ADR(winTitle));
  1808.                       END;
  1809.                       T.UnlockProject (mainProject);
  1810.  
  1811.                       SetlvName (nodePtr);
  1812.  
  1813.                       (* mettre à jour gadget listview *)
  1814.                       T.SetAttribute (mainProject, lvID, 0, sys.VAL(E.ULONG,sys.ADR(FileListHeader)));
  1815.  
  1816.                       (* Mettre à jour strings *)
  1817.                       UpdateStrGetfGads (actlvID);
  1818.  
  1819.  
  1820.                   (* Exécution de la commande sélectionnée *)
  1821.                   | exebuttID:
  1822.  
  1823.                       (* stocker les modifs dans les strings *)
  1824.                       SaveStrGads (actlvID);
  1825.  
  1826.                       (* Rechercher position de la sélection actuelle *)
  1827.                       nodePtr := FindNode (actlvID);
  1828.  
  1829.                       Execute (sys.VAL(_FilePtr, sys.ADR(nodePtr.file)));
  1830.  
  1831.  
  1832.                   (* Ajout d'une nouvelle entrée dans la liste *)
  1833.                   | newbuttID:
  1834.  
  1835.                       <* IF TEST THEN *>
  1836.                       dos.PrintF ("%s\n",sys.ADR("-->New"));
  1837.                       <* END *>
  1838.  
  1839.                       (* ne pas disposer nodePtr (est un élément de la liste) *)
  1840.                       NEW (nodePtr);
  1841.  
  1842.                       IF  nodePtr # NIL  THEN
  1843.                           InitFileNode (nodePtr);
  1844.                           SetlvName (nodePtr);
  1845.  
  1846.                           (* ajout du noeud en fin de liste *)
  1847.                           E.AddTail (FileListHeader, sys.VAL(E.CommonNodePtr, nodePtr));
  1848.  
  1849.                           (* mettre à jour le listview *)
  1850.                           T.SetAttribute (mainProject, lvID, 0, sys.VAL(E.ULONG,sys.ADR(FileListHeader)));
  1851.  
  1852.                           (* mettre strings à jour en fonction de l'entrée sélectionnée *)
  1853.                           actlvID := T.GetAttribute (mainProject, lvID, T.atValue);
  1854.                           UpdateStrGetfGads (actlvID);
  1855.  
  1856.                       ELSE
  1857.                           locStrPtr := L.CatStr(noMemN, noMemS);    OneGadReq (locStrPtr^);
  1858.                       END;
  1859.  
  1860.  
  1861.                   (* Effaçage d'une entrée de la liste *)
  1862.                   | delbuttID:
  1863.  
  1864.                       (* S'il existe encore un noeud *)
  1865.                       IF  ~listIsEmpty(sys.ADR(FileListHeader))  THEN
  1866.  
  1867.                         (* Rechercher position de la sélection actuelle *)
  1868.                         nodePtr := FindNode (actlvID);
  1869.  
  1870.                         (* Suppression du noeud de la liste *)
  1871.                         E.Remove (sys.VAL(E.CommonNodePtr, nodePtr));
  1872.  
  1873.                         (* Supprimer la notification correspondant au noeud *)
  1874.                         StopNotify1 (nodePtr.notify);
  1875.  
  1876.                         (* Supprimer le noeud de la mémoire *)
  1877.                         sys.DISPOSE (nodePtr);
  1878.  
  1879.                         (* mettre à jour gadget listview *)
  1880.                         T.SetAttribute (mainProject, lvID, 0, sys.VAL(E.ULONG,sys.ADR(FileListHeader)));
  1881.  
  1882.                         (* mettre strings à jour en fonction de l'entrée sélectionnée *)
  1883.                         actlvID := T.GetAttribute (mainProject, lvID, T.atValue);
  1884.                         UpdateStrGetfGads (actlvID);
  1885.                       END;
  1886.  
  1887.  
  1888.                   (* Sauvegarde définitive des modifs *)
  1889.                   | savebuttID, usebuttID:
  1890.  
  1891.                     (* stocker les modifs dans les strings *)
  1892.                     SaveStrGads (actlvID);
  1893.  
  1894.                     NotifyAll (FALSE);
  1895.                     NotifyAll (TRUE);
  1896.  
  1897.                     IF  eventID = savebuttID  THEN
  1898.                       IF  ~SaveConfig (sys.ADR(FileListHeader), envarc)  THEN
  1899.                         locStrPtr := L.CatStr(SEnvarcErrN, SEnvarcErrS);    OneGadReq (locStrPtr^);
  1900.                       END;
  1901.                     END;
  1902.  
  1903.                     IF  ~SaveConfig (sys.ADR(FileListHeader), env)  THEN
  1904.                       locStrPtr := L.CatStr(SEnvErrN, SEnvErrS);    OneGadReq (locStrPtr^);
  1905.                     END;
  1906.  
  1907.                     CloseGui ();
  1908.                     EXIT;
  1909.  
  1910.  
  1911.                   (* Cachage de la fenêtre *)
  1912.                   | hidebuttID:
  1913.  
  1914.                     CloseGui ();
  1915.                     <* IF TEST THEN *>
  1916.                     dos.PrintF ("%s", sys.ADR("Hide\n"));
  1917.                     <* END *>
  1918.                     EXIT;
  1919.  
  1920.  
  1921.                   (* Annulation des modifs (rechargement de l'ancien fichier de prefs) *)
  1922.                   | cancbuttID:
  1923.  
  1924.                     NotifyAll (FALSE);
  1925.  
  1926.                     (* S'il existe encore des noeuds tous les supprimer *)
  1927.                     RemAllFileNodes (sys.ADR(FileListHeader));
  1928.  
  1929.                     (* Charger l'ancienne config *)
  1930.                     IF  ~LoadConfig (sys.ADR(FileListHeader))  THEN
  1931.                       locStrPtr := L.CatStr(SEnvErrN, SEnvErrS);    OneGadReq (locStrPtr^);
  1932.                     END;
  1933.  
  1934.                     CloseGui ();
  1935.                     NotifyAll (TRUE);
  1936.                     EXIT;
  1937.  
  1938.  
  1939.  
  1940.                   ELSE  (* CASE eventID OF *)
  1941.                     <* IF TEST OR BETA THEN *>
  1942.                     dos.PrintF (">>>>>>>>  eventID inconnu <<<<<<<<<\n", NIL);
  1943.                     <* END *>
  1944.                   END;  (* CASE eventID OF *)
  1945.  
  1946.  
  1947.  
  1948.               | T.msError:
  1949.                     <* IF TEST OR BETA THEN *>
  1950.                     dos.PrintF (">>>>>>>>  ERREUR de TRITON <<<<<<<<<\n", NIL);
  1951.                     <* END *>
  1952.                     locStrPtr := L.CatStr(intTrErrN, intTrErrS);    OneGadReq (locStrPtr^);
  1953.                     quit := TRUE;
  1954.  
  1955.  
  1956.               ELSE  (* CASE eventclass OF *)
  1957.               END;
  1958.  
  1959.  
  1960.             (* Autre projet Triton: ne devrait jamais arriver ! *)
  1961.             ELSE  (* if messagePtr.project = mainProject *)
  1962.               <* IF TEST OR BETA THEN *>
  1963.               dos.PrintF ("%s\n",sys.ADR(">>>>>>>> AUTRE PROJECT !! <<<<<<<<<<"));
  1964.               <* END *>
  1965.               T.ReplyMsg (messagePtr);
  1966.             END;  (* if messagePtr.project = mainProject *)
  1967.  
  1968.  
  1969.         END;  (* LOOP *)
  1970.  
  1971.  
  1972.     END;  (*  WHILE ~quit  *)
  1973.  
  1974.  
  1975. END ManageGui;
  1976.  
  1977.  
  1978.  
  1979.  
  1980.  
  1981. <*$CopyArrays-*>
  1982. BEGIN
  1983.     Errors.Init;
  1984.  
  1985.     GetTT ();
  1986.  
  1987.     L.OpenCat ("MultiNotify.catalog", internalVer);
  1988.  
  1989.     NEW (projTagsPtr);
  1990.     IF  projTagsPtr#NIL  THEN
  1991.  
  1992.         IF  BrokerInit()  THEN
  1993.  
  1994.             NotifyMsgPortPtr := E.CreateMsgPort ();
  1995.             IF  NotifyMsgPortPtr # NIL  THEN
  1996.                 Kernel.SetCleanup (RemNotifyPort);
  1997.  
  1998.                 NotifyWaitSig := ComputeSig (NotifyMsgPortPtr.sigBit);
  1999.  
  2000.                 InitGuiTags (projTagsPtr^);
  2001.  
  2002.                 InitHeader ();
  2003.                 IF  ~LoadConfig (sys.ADR(FileListHeader))  THEN  openNow := TRUE  END;
  2004.  
  2005.                 NotifyAll (TRUE);
  2006.                 Kernel.SetCleanup (NotifyAllNow);
  2007.  
  2008.                 ManageGui (openNow);
  2009.  
  2010.                 <* IF TEST THEN *>
  2011.                 dos.PrintF ("%s\n",sys.ADR("fin du prog"));
  2012.                 <* END *>
  2013.             END;
  2014.         END;
  2015.     END;
  2016.  
  2017. END Main.
  2018.  
  2019.  
  2020.